package com.passion.common.frm;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.passion.common.util.MybatisPlusUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import org.apache.commons.lang3.StringUtils;

/**
 * 建类说明：分页查询公共参数
 * 当前版本：2.1.3
 *
 * @author 中国印
 * @since 2022年01月05日
 */
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor
public class PageFrm {

    /**
     * 属性说明：查询页
     *
     * @see Integer
     */
    private Integer page;

    /**
     * 属性说明：查询行数
     *
     * @see Integer
     */
    private Integer limit;
    private Integer rows;

    /**
     * 属性说明：排序字段
     *
     * @see String
     */
    private String sidx;

    /**
     * 属性说明：排序顺序
     *
     * @see String
     */
    private String order;

    /**
     * 给QueryWrapper填充排序
     *
     * @param wrapper 包装器
     * @return {@link QueryWrapper }<{@link T }>
     * @author ZhuYin
     * @since 2023/04/12
     */
    public <T> QueryWrapper<T> fillSort(QueryWrapper<T> wrapper) {
        if (StringUtils.isNotBlank(getSidx())) {
            if ("asc".equalsIgnoreCase(getOrder())) {
                if (getSidx().contains("_")) {
                    wrapper.orderByAsc(getSidx());
                } else {
                    wrapper.orderByAsc(StrUtil.toUnderlineCase(getSidx()));
                }
            } else {
                if (getSidx().contains("_")) {
                    wrapper.orderByDesc(getSidx());
                } else {
                    wrapper.orderByDesc(StrUtil.toUnderlineCase(getSidx()));
                }
            }
        } else {
            // 默认按创建时间降序排序
            wrapper.orderByDesc("create_time");
        }
        return wrapper;
    }

    /**
     * 给QueryWrapper填充排序，如若当前对象没有设置排序，则使用提供的默认排序
     *
     * @param wrapper     包装器
     * @param defaultSidx 如果未设置sidx，则使用指定的默认sidx，驼峰式和下划线式均支持
     * @param defaultAsc  如果未设置sidx和order，则使用指定的默认排序
     * @author ZhuYin
     * @since 2023/04/12
     */
    public <T> void fillSort(QueryWrapper<T> wrapper, String defaultSidx, boolean defaultAsc) {
        if (StringUtils.isNotBlank(getSidx())) {
            if ("asc".equalsIgnoreCase(getOrder())) {
                if (getSidx().contains("_")) {
                    wrapper.orderByAsc(getSidx());
                } else {
                    wrapper.orderByAsc(StrUtil.toUnderlineCase(getSidx()));
                }
            } else {
                if (getSidx().contains("_")) {
                    wrapper.orderByDesc(getSidx());
                } else {
                    wrapper.orderByDesc(StrUtil.toUnderlineCase(getSidx()));
                }
            }
        } else {
            // 按指定的字段和指定的顺序排序
            if (defaultAsc) {
                if (StringUtils.isNotBlank(defaultSidx)) {
                    if (defaultSidx.contains("_")) {
                        wrapper.orderByAsc(defaultSidx);
                    } else {
                        wrapper.orderByAsc(StrUtil.toUnderlineCase(defaultSidx));
                    }
                }
            } else {
                if (StringUtils.isNotBlank(defaultSidx)) {
                    if (defaultSidx.contains("_")) {
                        wrapper.orderByDesc(defaultSidx);
                    } else {
                        wrapper.orderByDesc(StrUtil.toUnderlineCase(defaultSidx));
                    }
                }
            }
        }
    }

    /**
     * 方法说明：给LambdaQueryWrapper填充排序
     *
     * @param wrapper Lambda包装器
     * @author ZhuYin
     * @since 2024年03月22日 11:18
     */
    public <T> void fillSort(LambdaQueryWrapper<T> wrapper) {
        OrderItem orderItem = new OrderItem();
        if (StringUtils.isNotBlank(getSidx())) {
            if (getSidx().contains("_")) {
                // 如果前端传的是带下划线的字段名称，则直接设置字段名称排序
                orderItem.setColumn(getSidx());
            } else {
                // 如果前端传的是驼峰式属性名称，将属性名称转成下划线字段名称再设置排序
                orderItem.setColumn(StrUtil.toUnderlineCase(getSidx()));
            }
            orderItem.setAsc("asc".equalsIgnoreCase(getOrder()));
        }
        MybatisPlusUtil.setOrderItem(wrapper, orderItem);
    }

    /**
     * 给LambdaQueryWrapper填充排序，如若当前对象未设置排序，则使用提供的默认排序
     *
     * @param wrapper     Lambda包装器
     * @param defaultSidx 如果未设置sidx，则使用指定的默认sidx，驼峰式和下划线式均支持
     * @param defaultAsc  如果未设置sidx和order，则使用指定的默认排序
     * @author ZhuYin
     * @since 2023/04/12
     */
    public <T> void fillSort(LambdaQueryWrapper<T> wrapper, String defaultSidx, boolean defaultAsc) {
        OrderItem orderItem = new OrderItem();
        if (StringUtils.isBlank(getSidx())) {
            // 如果未设置排序，则按照传入的默认列默认排序进行排序
            if (StringUtils.isNotBlank(defaultSidx)) {
                if (defaultSidx.contains("_")) {
                    orderItem.setColumn(defaultSidx);
                } else {
                    orderItem.setColumn(StrUtil.toUnderlineCase(defaultSidx));
                }
            }
            orderItem.setAsc(defaultAsc);
        } else {
            if (getSidx().contains("_")) {
                // 如果前端传的是带下划线的字段名称，则直接设置字段名称排序
                orderItem.setColumn(getSidx());
            } else {
                // 如果前端传的是驼峰式属性名称，将属性名称转成下划线字段名称再设置排序
                orderItem.setColumn(StrUtil.toUnderlineCase(getSidx()));
            }
            orderItem.setAsc("asc".equalsIgnoreCase(getOrder()));
        }
        MybatisPlusUtil.setOrderItem(wrapper, orderItem);
    }


    /**
     * 转成 分页 对象
     *
     * @return {@link Page }<{@link T }>
     * @author ZhuYin
     * @since 2023/04/12
     */
    public <T> Page<T> transferToPage() {
        return new Page<>(getPage(), getPageSize());
    }


    public int getPage() {
        if (this.page == null) {
            return 1;
        }
        return page;
    }

    public int getPageSize() {
        if (rows != null) {
            return rows;
        } else if (limit != null) {
            return limit;
        } else {
            // 默认最小给20条
            return 20;
        }
    }
    public int getLimit() {
        return getPageSize();
    }
    public int getRows() {
        return getPageSize();
    }

}
